In [8]:
import tensorflow as tf
from tensorflow.keras.applications import EfficientNetB0
from tensorflow.keras.layers import *
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.preprocessing.image import load_img, img_to_array
from tensorflow.keras.applications.efficientnet import preprocess_input
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import cv2
import os
import random
from PIL import Image
import re
from collections import Counter
from sklearn.model_selection import train_test_split
from sklearn.metrics.pairwise import cosine_similarity
import warnings
warnings.filterwarnings('ignore')
# Style dark theme
plt.style.use('dark_background')
sns.set_palette("husl")
# Seeds pour reproductibilité
SEED = 42
random.seed(SEED)
np.random.seed(SEED)
tf.random.set_seed(SEED)
# HYPERPARAMETERS - Recipe Image Retrieval avec EfficientNet
CONFIG = {
# === IMAGE PARAMETERS ===
'IMG_SIZE': 224, # Optimal pour EfficientNet
'BATCH_SIZE': 32, # Bon équilibre mémoire/performance
# === EMBEDDING PARAMETERS ===
'EMBEDDING_DIM_NATIVE': 1280, # EfficientNet features natives
'EMBEDDING_DIM_CUSTOM': 512, # Custom head output (si fine-tuning)
# === PHASE 1: FEATURE EXTRACTION ===
'USE_NATIVE_FEATURES': True, # True = 1280-dim, False = 512-dim custom
# === PHASE 2: TRANSFER LEARNING ===
'TRANSFER_EPOCHS': 15, # Entraînement head seulement
'TRANSFER_LR': 0.001, # Learning rate plus élevé pour nouvelles couches
'TRANSFER_BATCH_SIZE': 32, # Plus petit pour stabilité
# === PHASE 3: FINE-TUNING ===
'FINETUNE_EPOCHS': 20, # Fine-tuning complet
'FINETUNE_LR': 0.0001, # Learning rate faible pour pré-entraîné
'FINETUNE_BATCH_SIZE': 16, # Plus petit pour stabilité
'FINETUNE_UNFREEZE_LAYERS': 20, # Nombre de couches à dégeler
# === TRAINING PARAMETERS ===
'TRIPLET_MARGIN': 0.8, # Augmenté pour meilleure séparation
'DROPOUT_RATE': 0.3, # Régularisation
'WEIGHT_DECAY': 0.0001, # L2 regularization
# === OPTIMIZATION ===
'OPTIMIZER': 'adam', # Standard
'PATIENCE': 3, # Early stopping
'REDUCE_LR_PATIENCE': 2, # Réduction LR
'REDUCE_LR_FACTOR': 0.5, # Facteur réduction
# === DATA AUGMENTATION ===
'USE_AUGMENTATION': True, # Pour fine-tuning
'ROTATION_RANGE': 15, # Rotation aléatoire
'ZOOM_RANGE': 0.1, # Zoom aléatoire
'HORIZONTAL_FLIP': True, # Flip horizontal
# === EVALUATION ===
'SIMILARITY_THRESHOLD': 0.7, # Seuil similarité
'TOP_K_RESULTS': 3, # Nombre résultats retournés
'VALIDATION_SPLIT': 0.2, # Split pour validation
}
# HYPERPARAMÈTRES Fine-Tuning
CONFIG_FT = {
# === IMAGE PARAMETERS ===
'IMG_SIZE': 224, # Optimal pour EfficientNet
'BATCH_SIZE': 32, # Plus petit pour le fine-tuning si on fait du hard negative sampling
'LAYERS_TO_UNFREEZE': 40, # Nombre de couches à dégeler
# === EMBEDDING PARAMETERS ===
'EMBEDDING_DIM_NATIVE': 1280, # EfficientNet features natives
'EMBEDDING_DIM_CUSTOM': 512, # Custom head output
# === FINE-TUNING (TRIPLET) ===
'HEAD_EPOCHS': 6, # Entraînement head seulement (on a déjà testé et on a trouvé que c'est suffisant)
'BACKBONE_EPOCHS': 20, # Entraînement des couches dégelées
'HEAD_LR': 0.001, # Entraînement avec triplet loss
'BACKBONE_LR': 0.00001, # Learning rate pour nouvelles couches
'TRIPLET_MARGIN': 0.8, # Marge triplet loss
'DROPOUT_RATE': 0.3, # Régularisation
'WEIGHT_DECAY': 0.0001, # L2 regularization
# === OPTIMIZATION AVANCÉE ===
'OPTIMIZER': 'adam', # Standard
'PATIENCE': 3, # Early stopping
'REDUCE_LR_PATIENCE': 2, # Réduction LR
'REDUCE_LR_FACTOR': 0.5, # Facteur réduction
'MIN_LR': 1e-8, # LR minimum
# === DATA AUGMENTATION ===
'USE_AUGMENTATION': True, # Augmentation
'ROTATION_RANGE': 15, # Rotation aléatoire
'ZOOM_RANGE': 0.1, # Zoom aléatoire
'BRIGHTNESS_RANGE': [0.9, 1.1], # Luminosité
'HORIZONTAL_FLIP': True, # Flip horizontal
# === VALIDATION & ÉVALUATION ===
'VALIDATION_SPLIT': 0.2, # Split pour validation
'TOP_K_RESULTS': 3, # Nombre résultats
'MIN_IMAGES_PER_RECIPE': 1, # Filtrage minimum
'MAX_PAIRS_PER_RECIPE': 5, # Limite paires par recette
# === MODÈLE ===
'MODEL_NAME': 'recipe_image_retrieval_model_ft.keras',
'EMBEDDINGS_NAME': 'recipe_embeddings_database_ft.npy',
'METADATA_NAME': 'recipe_embeddings_database_metadata_ft.pkl'
}
print("Configuration adaptée pour EfficientNet Fine Tuning")
print(f"Phase 3: Fine-tuning ({CONFIG['EMBEDDING_DIM_CUSTOM']}-dim, {CONFIG['FINETUNE_EPOCHS']} epochs)")
print("Imports et configuration OK!")
print(f"TensorFlow: {tf.__version__}")
print(f"GPU: {tf.config.list_physical_devices('GPU')}")
Configuration adaptée pour EfficientNet Fine Tuning Phase 3: Fine-tuning (512-dim, 20 epochs) Imports et configuration OK! TensorFlow: 2.19.0 GPU: [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
2. Couches personnalisées¶
In [9]:
from tensorflow.keras.layers import Layer
# COUCHE L2 NORMALIZATION PERSONNALISÉE (SÉRIALISABLE)
class L2NormalizationLayer(Layer):
"""Couche personnalisée pour normalisation L2 - sérialisable"""
def __init__(self, axis=1, **kwargs):
super(L2NormalizationLayer, self).__init__(**kwargs)
self.axis = axis
def call(self, inputs):
return tf.nn.l2_normalize(inputs, axis=self.axis)
def compute_output_shape(self, input_shape):
return input_shape
def get_config(self):
config = super(L2NormalizationLayer, self).get_config()
config.update({'axis': self.axis})
return config
# COUCHE EXTRACTION TRIPLET PERSONNALISÉE (SÉRIALISABLE)
class ExtractTripletComponent(Layer):
"""Couche pour extraire une composante du triplet"""
def __init__(self, component_index, **kwargs):
super(ExtractTripletComponent, self).__init__(**kwargs)
self.component_index = component_index
def call(self, inputs):
return inputs[:, self.component_index]
def compute_output_shape(self, input_shape):
# input_shape = (batch_size, 3, height, width, channels)
return (input_shape[0], input_shape[2], input_shape[3], input_shape[4])
def get_config(self):
config = super(ExtractTripletComponent, self).get_config()
config.update({'component_index': self.component_index})
return config
# COUCHE STACK TRIPLET PERSONNALISÉE (SÉRIALISABLE)
class TripletStackLayer(Layer):
"""Couche personnalisée pour empiler les embeddings triplet"""
def __init__(self, **kwargs):
super(TripletStackLayer, self).__init__(**kwargs)
def call(self, inputs):
# inputs = [anchor_emb, positive_emb, negative_emb]
return tf.stack(inputs, axis=1)
def compute_output_shape(self, input_shape):
# input_shape = [(batch_size, embedding_dim), ...]
batch_size = input_shape[0][0]
embedding_dim = input_shape[0][1]
return (batch_size, 3, embedding_dim)
def get_config(self):
return super(TripletStackLayer, self).get_config()
3. Gestion des triplets et de la triplet loss¶
In [10]:
# FINE TUNING - Triplet Loss + EfficientNetB0
# ================================================================================
# Triplet Loss (meilleur que Contrastive)
# Architecture robuste + gestion d'erreurs
# Hyperparamètres avancés (weight decay, reduce LR, validation)
# Callbacks pour l'entraînement
import os
import pickle
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from PIL import Image
import tensorflow as tf
from tensorflow.keras.applications import EfficientNetB0
from tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout, Layer
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint, TensorBoard
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications.efficientnet import preprocess_input
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.model_selection import train_test_split
import time
from tqdm import tqdm
import warnings
warnings.filterwarnings('ignore')
print(f"Configuration Fine-Tuning:")
print(f"- Taille des images: {CONFIG_FT['IMG_SIZE']}x{CONFIG_FT['IMG_SIZE']}")
print(f"- Taille du batch : {CONFIG_FT['BATCH_SIZE']}")
print(f"- Nb Epochs phase 1 (fixé à 6 car on connait sur autre notebook): {CONFIG_FT['HEAD_EPOCHS']}")
print(f"- Max Epochs phase 2: {CONFIG_FT['BACKBONE_EPOCHS']}")
print(f"- Learning Rate phase 1: {CONFIG_FT['HEAD_LR']}")
print(f"- Learning Rate phase 2: {CONFIG_FT['BACKBONE_LR']}")
print(f"- Embedding Dim: {CONFIG_FT['EMBEDDING_DIM_CUSTOM']} (custom)")
print(f"- Triplet Margin: {CONFIG_FT['TRIPLET_MARGIN']}")
print(f"- Dropout Rate: {CONFIG_FT['DROPOUT_RATE']}")
print(f"- Weight Decay: {CONFIG_FT['WEIGHT_DECAY']}")
print(f"- Early Stopping phase 2: {CONFIG_FT['PATIENCE']} epochs")
# PREPROCESSING
def preprocess_image(image_path, img_size=224):
"""Preprocessing robuste avec gestion d'erreurs complète + preprocessing natif EfficientNet"""
try:
if not os.path.exists(image_path):
return None
# Vérifier la taille du fichier (éviter fichiers corrompus)
if os.path.getsize(image_path) < 1024: # Moins de 1KB
return None
img = Image.open(image_path)
# Vérifier si l'image est valide
img.verify()
img = Image.open(image_path)
# Convertir en RGB si nécessaire
if img.mode != 'RGB':
img = img.convert('RGB')
# Redimensionner avec qualité optimale
img = img.resize((img_size, img_size), Image.Resampling.LANCZOS)
# Convertir en array et appliquer preprocessing EfficientNet
img_array = np.array(img, dtype=np.float32)
# Normalisation EfficientNet native
img_array = preprocess_input(img_array)
return img_array
except Exception as e:
return None
# TRIPLET LOSS AVEC EMBEDDINGS NORMALISÉS
def triplet_loss(margin=0.3):
"""Triplet loss avec embeddings L2-normalisés"""
def triplet_loss_fn(y_true, y_pred):
"""
y_pred contient [anchor, positive, negative] embeddings normalisés
Utilise distance cosinus (1 - similarity) pour la loss
"""
anchor = y_pred[:, 0, :] # (batch_size, embedding_dim)
positive = y_pred[:, 1, :] # (batch_size, embedding_dim)
negative = y_pred[:, 2, :] # (batch_size, embedding_dim)
# Calcul des distances cosinus (1 - similarité cosinus)
# Pour embeddings normalisés: cosine_sim = dot_product
pos_similarity = tf.reduce_sum(anchor * positive, axis=1)
neg_similarity = tf.reduce_sum(anchor * negative, axis=1)
pos_distance = 1.0 - pos_similarity
neg_distance = 1.0 - neg_similarity
# Triplet loss: max(0, pos_dist - neg_dist + margin)
basic_loss = pos_distance - neg_distance + margin
loss = tf.maximum(0.0, basic_loss)
return tf.reduce_mean(loss)
return triplet_loss_fn
# visualisation des triplets
def show_triplets(generator, n_triplets=10, title=None):
"""Affiche n triplets (anchor, positive, negative) depuis un batch du générateur"""
try:
# Générer un batch de triplets
triplet_batch, _ = generator._generate_triplet_batch()
print(f"Format du batch triplet: {triplet_batch.shape}")
# Extraire les anchors, positives, negatives
anchors = triplet_batch[:, 0, :, :, :]
positives = triplet_batch[:, 1, :, :, :]
negatives = triplet_batch[:, 2, :, :, :]
n_triplets = min(n_triplets, len(anchors))
except Exception as e:
print(f"Erreur lors de la génération du batch: {e}")
return
def normalize_image_efficientnet(img):
"""Normalise l'image EfficientNet pour l'affichage"""
if hasattr(img, 'numpy'):
img = img.numpy()
# Copier pour éviter de modifier l'original
img = np.copy(img)
# EfficientNet preprocess_input utilise une normalisation spécifique
# Les valeurs sont généralement dans [-1, 1] ou [-2, 2]
# Méthode 1: Normalisation standard
img_min = img.min()
img_max = img.max()
if img_max > img_min:
img = (img - img_min) / (img_max - img_min)
else:
# Image uniforme, mettre à 0.5
img = np.full_like(img, 0.5)
return np.clip(img, 0, 1)
# Calculer les statistiques de difficulté
print(f"\n=== ANALYSE DE LA DIFFICULTÉ DES TRIPLETS ===")
difficulties = []
for i in range(min(5, n_triplets)):
anchor = anchors[i]
positive = positives[i]
negative = negatives[i]
# Calculer les distances L2
pos_dist = np.mean((anchor - positive) ** 2)
neg_dist = np.mean((anchor - negative) ** 2)
difficulty_ratio = neg_dist / (pos_dist + 1e-8)
difficulties.append(difficulty_ratio)
print(f"Triplet {i+1}:")
print(f"- Distance anchor-positive: {pos_dist:.4f}")
print(f"- Distance anchor-negative: {neg_dist:.4f}")
print(f"- Ratio difficulté: {difficulty_ratio:.2f} {'(FACILE)' if difficulty_ratio > 3 else '(DIFFICILE)'}")
avg_difficulty = np.mean(difficulties)
print(f"\nDifficulté moyenne: {avg_difficulty:.2f}")
print(f"Évaluation: {'TRIPLETS TROP FACILES' if avg_difficulty > 3 else 'TRIPLETS APPROPRIÉS'}")
# Affichage visuel
plt.figure(figsize=(12, 4 * n_triplets))
for i in range(n_triplets):
for j, (img, label) in enumerate([(anchors[i], "Anchor"),
(positives[i], "Positive"),
(negatives[i], "Negative")]):
plt.subplot(n_triplets, 3, i * 3 + j + 1)
try:
# Utiliser la nouvelle fonction de normalisation
normalized_img = normalize_image_efficientnet(img)
# Debug: afficher les stats de l'image
print(f"Image {i+1}-{label}: min={img.min():.3f}, max={img.max():.3f}, mean={img.mean():.3f}")
print(f"Normalisée: min={normalized_img.min():.3f}, max={normalized_img.max():.3f}")
plt.imshow(normalized_img)
plt.axis('off')
plt.title(f"{label}")
# Ajouter info de difficulté pour le premier triplet
if i == 0 and j == 0:
plt.xlabel(f"Difficulté: {difficulties[0]:.2f}")
except Exception as e:
print(f"Erreur affichage image {i+1}-{label}: {e}")
plt.text(0.5, 0.5, f"Erreur: {str(e)[:50]}",
ha='center', va='center', transform=plt.gca().transAxes)
plt.axis('off')
if title:
plt.suptitle(title, fontsize=16)
else:
plt.suptitle(f"Triplets - Difficulté moyenne: {avg_difficulty:.2f}", fontsize=16)
plt.tight_layout()
plt.show()
# GÉNÉRATEUR DE TRIPLETS
class TripletGenerator(tf.keras.utils.Sequence):
"""Générateur de triplets avec validation et augmentation avancée"""
def __init__(self, recipes_df, batch_size=32, img_size=224, augment=True, validation_split=0.2, is_validation=False):
self.batch_size = batch_size
self.img_size = img_size
self.augment = augment and not is_validation
self.is_validation = is_validation
# Filtrer et diviser les données
self.valid_recipes = self._filter_valid_recipes(recipes_df)
self.train_recipes, self.val_recipes = self._split_data(validation_split)
# Utiliser le bon subset
self.recipes_df = self.val_recipes if is_validation else self.train_recipes
# Grouper par titre de recette
self.recipe_groups = self.recipes_df.groupby('Title')
self.recipe_names = list(self.recipe_groups.groups.keys())
# Configuration augmentation de données
if self.augment:
self.datagen = ImageDataGenerator(
rotation_range=CONFIG_FT['ROTATION_RANGE'],
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=CONFIG_FT['HORIZONTAL_FLIP'],
zoom_range=CONFIG_FT['ZOOM_RANGE'],
brightness_range=CONFIG_FT['BRIGHTNESS_RANGE'],
fill_mode='nearest'
)
self.on_epoch_end()
split_name = "Validation" if is_validation else "Entraînement"
print(f"Générateur {split_name} créé:")
print(f"- Recettes: {len(self.recipe_names)}")
print(f"- Images: {len(self.recipes_df)}")
print(f"- Augmentation: {'Activée' if self.augment else 'Désactivée'}")
def _filter_valid_recipes(self, recipes_df):
"""Filtrer les recettes avec images valides"""
valid_recipes = []
print("Filtrage des images valides...")
for idx, row in tqdm(recipes_df.iterrows(), total=len(recipes_df), desc="Validation images"):
if pd.notna(row['image_path']) and os.path.exists(row['image_path']):
try:
img = Image.open(row['image_path'])
img.verify()
valid_recipes.append(row)
except:
continue
result_df = pd.DataFrame(valid_recipes)
print(f"{len(result_df)}/{len(recipes_df)} images valides")
return result_df
def _split_data(self, validation_split):
"""Diviser les données en train/validation par recette"""
unique_recipes = self.valid_recipes['Title'].unique()
train_recipes, val_recipes = train_test_split(
unique_recipes,
test_size=validation_split,
random_state=42
)
train_df = self.valid_recipes[self.valid_recipes['Title'].isin(train_recipes)]
val_df = self.valid_recipes[self.valid_recipes['Title'].isin(val_recipes)]
return train_df, val_df
def __len__(self):
return max(1, len(self.recipes_df) // self.batch_size)
def __getitem__(self, index):
return self._generate_triplet_batch()
def on_epoch_end(self):
"""Mélanger les données à chaque époque"""
pass
def _generate_triplet_batch(self):
"""Générer un batch de triplets avec gestion robuste des erreurs"""
batch_size = self.batch_size
anchors = np.zeros((batch_size, self.img_size, self.img_size, 3), dtype=np.float32)
positives = np.zeros((batch_size, self.img_size, self.img_size, 3), dtype=np.float32)
negatives = np.zeros((batch_size, self.img_size, self.img_size, 3), dtype=np.float32)
valid_triplets = 0
attempts = 0
# Plus de tentatives pour robustesse
max_attempts = batch_size * 5
while valid_triplets < batch_size and attempts < max_attempts:
attempts += 1
try:
# Sélectionner une recette positive (avec au moins 1 image)
pos_recipe = np.random.choice(self.recipe_names)
pos_group = self.recipe_groups.get_group(pos_recipe)
# Sélectionner une recette négative différente
available_neg_recipes = [r for r in self.recipe_names if r != pos_recipe]
if not available_neg_recipes:
continue
neg_recipe = np.random.choice(available_neg_recipes)
neg_group = self.recipe_groups.get_group(neg_recipe)
# Sélectionner les images du triplet
if len(pos_group) >= 2:
# Cas idéal: 2 images différentes de la même recette
anchor_row, pos_row = pos_group.sample(2).iloc
else:
# Cas limite: même image pour anchor et positive
anchor_row = pos_row = pos_group.iloc[0]
# Image négative d'une recette différente
neg_row = neg_group.sample(1).iloc[0]
# Charger et préprocesser les images
anchor_img = preprocess_image(anchor_row['image_path'], self.img_size)
pos_img = preprocess_image(pos_row['image_path'], self.img_size)
neg_img = preprocess_image(neg_row['image_path'], self.img_size)
# Vérifier que toutes les images sont valides
if anchor_img is not None and pos_img is not None and neg_img is not None:
# Appliquer l'augmentation de données
if self.augment:
# Pas d'augmentation sur anchor et negative
pos_img = self.datagen.random_transform(pos_img)
# Ajouter au batch
anchors[valid_triplets] = anchor_img
positives[valid_triplets] = pos_img
negatives[valid_triplets] = neg_img
valid_triplets += 1
except Exception as e:
print(f"Erreur sur un triplet: {e}")
continue
# Compléter avec des copies si nécessaire (cas rare)
while valid_triplets < batch_size:
print(f"Pas assez de triplets valides: {valid_triplets}")
copy_idx = np.random.randint(0, max(1, valid_triplets))
anchors[valid_triplets] = anchors[copy_idx]
positives[valid_triplets] = positives[copy_idx]
negatives[valid_triplets] = negatives[copy_idx]
valid_triplets += 1
# Format pour le modèle triplet: (batch_size, 3, height, width, channels)
triplet_batch = np.stack([anchors, positives, negatives], axis=1)
dummy_labels = np.zeros((batch_size, 1)) # Non utilisé avec triplet loss
return triplet_batch, dummy_labels
class HardTripletGenerator(TripletGenerator):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.embedding_cache = {}
self.update_frequency = 50 # Recalculer tous les 50 batches
self.batch_count = 0
def _select_hard_negative(self, pos_recipe, anchor_row):
"""Sélectionne un negative difficile"""
# Pour l'instant, sélection aléatoire (à améliorer avec embeddings)
available_neg_recipes = [r for r in self.recipe_names if r != pos_recipe]
# TODO: Améliorer avec similarité des embeddings
# Pour l'instant, on fait du random
return np.random.choice(available_neg_recipes)
def _strong_augmentation(self, img):
"""Augmentation plus forte pour rendre les positives plus difficiles"""
# Attention: img est déjà normalisé par EfficientNet preprocess_input
# Les valeurs sont dans [-1, 1] environ
# Augmentation normale d'abord
img = self.datagen.random_transform(img)
# Augmentations supplémentaires légères
if np.random.random() < 0.3:
# Bruit gaussien très léger
noise = np.random.normal(0, 0.02, img.shape)
img = img + noise
if np.random.random() < 0.2:
# Légère modification de contraste
img = img * np.random.uniform(0.95, 1.05)
return img
def _generate_triplet_batch(self):
"""Générer un batch de triplets avec gestion robuste des erreurs"""
batch_size = self.batch_size
anchors = np.zeros((batch_size, self.img_size, self.img_size, 3), dtype=np.float32)
positives = np.zeros((batch_size, self.img_size, self.img_size, 3), dtype=np.float32)
negatives = np.zeros((batch_size, self.img_size, self.img_size, 3), dtype=np.float32)
valid_triplets = 0
attempts = 0
# Plus de tentatives pour robustesse
max_attempts = batch_size * 5
while valid_triplets < batch_size and attempts < max_attempts:
attempts += 1
try:
# Sélectionner une recette positive (avec au moins 1 image)
pos_recipe = np.random.choice(self.recipe_names)
pos_group = self.recipe_groups.get_group(pos_recipe)
# Sélectionner une recette négative différente
available_neg_recipes = [r for r in self.recipe_names if r != pos_recipe]
if not available_neg_recipes:
continue
neg_recipe = np.random.choice(available_neg_recipes)
neg_group = self.recipe_groups.get_group(neg_recipe)
# Sélectionner les images du triplet
if len(pos_group) >= 2:
# Cas idéal: 2 images différentes de la même recette
anchor_row, pos_row = pos_group.sample(2).iloc
else:
# Cas limite: même image pour anchor et positive
anchor_row = pos_row = pos_group.iloc[0]
# Image négative d'une recette différente
neg_row = neg_group.sample(1).iloc[0]
# Charger et préprocesser les images
anchor_img = preprocess_image(anchor_row['image_path'], self.img_size)
pos_img = preprocess_image(pos_row['image_path'], self.img_size)
neg_img = preprocess_image(neg_row['image_path'], self.img_size)
# Vérifier que toutes les images sont valides
if anchor_img is not None and pos_img is not None and neg_img is not None:
# Appliquer l'augmentation de données
if self.augment:
# Pas d'augmentation sur anchor et negative
pos_img = self.datagen.random_transform(pos_img)
# Ajouter au batch
anchors[valid_triplets] = anchor_img
positives[valid_triplets] = pos_img
negatives[valid_triplets] = neg_img
valid_triplets += 1
except Exception as e:
print(f"Erreur sur un triplet: {e}")
continue
# Compléter avec des copies si nécessaire (cas rare)
while valid_triplets < batch_size:
print(f"Pas assez de triplets valides: {valid_triplets}")
copy_idx = np.random.randint(0, max(1, valid_triplets))
anchors[valid_triplets] = anchors[copy_idx]
positives[valid_triplets] = positives[copy_idx]
negatives[valid_triplets] = negatives[copy_idx]
valid_triplets += 1
# Format pour le modèle triplet: (batch_size, 3, height, width, channels)
triplet_batch = np.stack([anchors, positives, negatives], axis=1)
dummy_labels = np.zeros((batch_size, 1)) # Non utilisé avec triplet loss
return triplet_batch, dummy_labels
# MODÈLE TRIPLET POUR ENTRAÎNEMENT
def create_triplet_model(embedding_model):
"""Modèle triplet avec couches personnalisées sérialisables"""
# Input: batch de triplets (batch_size, 3, height, width, channels)
triplet_input = tf.keras.layers.Input(
shape=(3, CONFIG_FT['IMG_SIZE'], CONFIG_FT['IMG_SIZE'], 3),
name='triplet_input'
)
anchor = ExtractTripletComponent(0, name='extract_anchor')(triplet_input)
positive = ExtractTripletComponent(1, name='extract_positive')(triplet_input)
negative = ExtractTripletComponent(2, name='extract_negative')(triplet_input)
# Obtenir les embeddings normalisés
anchor_emb = embedding_model(anchor)
positive_emb = embedding_model(positive)
negative_emb = embedding_model(negative)
triplet_output = TripletStackLayer(name='combine_embeddings')([anchor_emb, positive_emb, negative_emb])
model = Model(inputs=triplet_input, outputs=triplet_output, name='TransferLearningTripletModel')
print(f"Modèle triplet créé:")
print(f"- Input shape: {model.input_shape}")
print(f"- Output shape: {model.output_shape}")
return model
# MÉTRIQUES
def triplet_margin_accuracy(y_true, y_pred):
"""% de triplets qui respectent la marge complète (vraie réussite)"""
anchor = y_pred[:, 0, :]
positive = y_pred[:, 1, :]
negative = y_pred[:, 2, :]
pos_similarity = tf.reduce_sum(anchor * positive, axis=1)
neg_similarity = tf.reduce_sum(anchor * negative, axis=1)
# Distance cosinus
pos_distance = 1.0 - pos_similarity
neg_distance = 1.0 - neg_similarity
# Triplet satisfait si : neg_dist - pos_dist > margin
margin = CONFIG_FT['TRIPLET_MARGIN'] # Utiliser la marge configurée
margin_satisfied = tf.cast(neg_distance - pos_distance > margin, tf.float32)
return tf.reduce_mean(margin_satisfied)
def average_positive_similarity(y_true, y_pred):
"""Similarité moyenne anchor-positive"""
anchor = y_pred[:, 0, :]
positive = y_pred[:, 1, :]
pos_similarity = tf.reduce_sum(anchor * positive, axis=1)
return tf.reduce_mean(pos_similarity)
def average_negative_similarity(y_true, y_pred):
"""Similarité moyenne anchor-negative"""
anchor = y_pred[:, 0, :]
negative = y_pred[:, 2, :]
neg_similarity = tf.reduce_sum(anchor * negative, axis=1)
return tf.reduce_mean(neg_similarity)
Configuration Fine-Tuning: - Taille des images: 224x224 - Taille du batch : 32 - Nb Epochs phase 1 (fixé à 6 car on connait sur autre notebook): 6 - Max Epochs phase 2: 20 - Learning Rate phase 1: 0.001 - Learning Rate phase 2: 1e-05 - Embedding Dim: 512 (custom) - Triplet Margin: 0.8 - Dropout Rate: 0.3 - Weight Decay: 0.0001 - Early Stopping phase 2: 3 epochs
4. Phase 1 : Transfer Learning (entraînement de la tête)¶
In [11]:
# MODELE PHASE 1
def create_embedding_model_phase1(embedding_dim=512):
"""Modèle d'embedding pour entrainer la tête uniquement avec triplet loss"""
# Base EfficientNetB0
base_model = EfficientNetB0(
weights='imagenet',
include_top=False,
input_shape=(CONFIG_FT['IMG_SIZE'], CONFIG_FT['IMG_SIZE'], 3)
)
# Geler toutes les couches d'abord
for layer in base_model.layers:
layer.trainable = False
# Custom head
x = base_model.output
x = GlobalAveragePooling2D(name='global_avg_pool')(x)
embeddings = Dense(embedding_dim, activation=None, name='embeddings')(x)
# Normalisation L2 pour ce soit compatible avec triplet loss + similarité cosinus
embeddings_normalized = L2NormalizationLayer(axis=1, name='l2_norm')(embeddings)
# Modèle final
model = Model(inputs=base_model.input, outputs=embeddings_normalized, name='TransferLearningEmbeddingModel')
# Afficher le résumé (décommenter si besoin de voir les couches)
# model.summary()
print(f"Modèle d'embedding phase 1 créé:")
print(f"- Params totaux: {model.count_params():,}")
print(f"- Params entraînables: {sum([tf.size(w) for w in model.trainable_weights]):,}")
print(f"- Architecture: EfficientNetB0 + Fine Tuning, phase 1 ({embedding_dim}D)")
return model
# FONCTION D'ENTRAÎNEMENT PHASE 1
def train_transfer_learning_phase1():
"""Entraînement complet avec toutes les optimisations"""
print("Début de l'entraînement Fine-Tuning phase 1...")
print("=" * 60)
# Charger les données
try:
recipes_df = pd.read_pickle("./data/recipes_with_images_dataframe.pkl")
print(f"{len(recipes_df)} recettes chargées depuis le DataFrame")
except FileNotFoundError:
print("Fichier ./data/recipes_with_images_dataframe.pkl introuvable")
print("Assurez-vous d'avoir exécuté le notebook 'raw' qui génère le DataFrame sous forme de pickle")
return None, None
# Créer le modèle d'embedding phase 1
print("\nCréation du modèle d'embedding phase 1...")
embedding_model_phase1 = create_embedding_model_phase1(
embedding_dim=CONFIG_FT['EMBEDDING_DIM_CUSTOM']
)
# Créer les générateurs de données (train + validation)
print("\nCréation des générateurs de données...")
train_generator = HardTripletGenerator(
recipes_df,
batch_size=CONFIG_FT['BATCH_SIZE'],
img_size=CONFIG_FT['IMG_SIZE'],
augment=CONFIG_FT['USE_AUGMENTATION'],
validation_split=CONFIG_FT['VALIDATION_SPLIT'],
is_validation=False
)
val_generator = HardTripletGenerator(
recipes_df,
batch_size=CONFIG_FT['BATCH_SIZE'],
img_size=CONFIG_FT['IMG_SIZE'],
augment=False, # Pas d'augmentation en validation
validation_split=CONFIG_FT['VALIDATION_SPLIT'],
is_validation=True
)
# Créer le modèle triplet phase 1
triplet_model_phase1 = create_triplet_model(embedding_model_phase1)
# Compiler le modèle phase 1 entrainement de la tête uniquement
triplet_model_phase1.compile(
optimizer=Adam(
learning_rate=CONFIG_FT['HEAD_LR'],
weight_decay=CONFIG_FT['WEIGHT_DECAY']
),
loss=triplet_loss(margin=CONFIG_FT['TRIPLET_MARGIN']),
metrics=[triplet_margin_accuracy, average_positive_similarity, average_negative_similarity]
)
print(f"Modèle phase 1 compilé (entrainement de la tête uniquement):")
print(f"- Optimizer: Adam (lr={CONFIG_FT['HEAD_LR']}, wd={CONFIG_FT['WEIGHT_DECAY']})")
print(f"- Loss: Triplet Loss (margin={CONFIG_FT['TRIPLET_MARGIN']})")
print(f"- Métriques: Accuracy + Similarités moyenne")
# CALLBACK PERSONNALISÉ pour adapter le margin de triplet loss
class AdaptiveMarginCallback(tf.keras.callbacks.Callback):
def __init__(self, initial_margin=CONFIG_FT['TRIPLET_MARGIN']):
self.margin = initial_margin
def on_epoch_end(self, epoch, logs=None):
triplet_acc = logs.get('triplet_margin_accuracy', 0)
if triplet_acc > 0.95: # Trop facile
self.margin += 0.1
print(f"Augmentation margin à {self.margin}")
elif triplet_acc < 0.7: # Trop difficile
self.margin -= 0.05
print(f"Réduction margin à {self.margin}")
# Callbacks pour l'entraînement phase 1
callbacks_phase1= [
ReduceLROnPlateau(
monitor='val_loss',
patience=CONFIG_FT['REDUCE_LR_PATIENCE'],
factor=CONFIG_FT['REDUCE_LR_FACTOR'],
min_lr=CONFIG_FT['MIN_LR'],
verbose=1,
mode='min'
),
AdaptiveMarginCallback(initial_margin=CONFIG_FT['TRIPLET_MARGIN']),
]
print(f"6 époques fixées pour l'entraînement phase 1 car on a déjà testé et on a trouvé que c'est suffisant")
print(f"Callbacks configurés pour phase 1:")
print(f"- Reduce LR: patience={CONFIG_FT['REDUCE_LR_PATIENCE']}, factor={CONFIG_FT['REDUCE_LR_FACTOR']}")
print(f"- Adaptive Margin: initial={CONFIG_FT['TRIPLET_MARGIN']}")
# Entraînement
start_time_phase1 = time.time()
print("\nEntraînement phase 1...")
history_phase1 = triplet_model_phase1.fit(
train_generator,
epochs=CONFIG_FT['HEAD_EPOCHS'],
validation_data=val_generator,
callbacks=callbacks_phase1,
verbose=1
)
training_time_phase1 = time.time() - start_time_phase1
# Afficher les résultats
print("\n" + "="*60)
print(" ENTRAÎNEMENT PHASE 1 TERMINÉ AVEC SUCCÈS!")
print("="*60)
print(f"⏱ Temps total: {training_time_phase1 /60:.1f} minutes")
print(f" Meilleure val_loss: {min(history_phase1.history['val_loss']):.4f}")
print(f" Précision finale: {history_phase1.history['val_triplet_margin_accuracy'][-1]:.4f}")
print(f" Similarité pos finale: {history_phase1.history['val_average_positive_similarity'][-1]:.4f}")
print(f" Similarité neg finale: {history_phase1.history['val_average_negative_similarity'][-1]:.4f}")
return embedding_model_phase1, history_phase1
5. Phase 2 : Fine-Tuning (entraînement des couches dégelées)¶
In [12]:
def create_embedding_model_phase2(embedding_model_phase1, embedding_dim=512):
"""Modèle d'embedding phase 2 avec fine-tuning (dégel partiel du backbone)"""
print(f"Total des couches EfficientNet + custom head: {len(embedding_model_phase1.layers)}")
# Exclure les 5 dernières couches (la tête custom)
head_size = 5
backbone_layers = embedding_model_phase1.layers[:-head_size]
layers_to_unfreeze = CONFIG_FT['LAYERS_TO_UNFREEZE']
print(f"Dégel des {layers_to_unfreeze} dernières couches du backbone...")
# Dégeler les N dernières couches du backbone
for layer in backbone_layers[-layers_to_unfreeze:]:
layer.trainable = True
# Statistiques (backbone uniquement)
frozen_layers = sum([1 for layer in backbone_layers if not layer.trainable])
trainable_layers = sum([1 for layer in backbone_layers if layer.trainable])
print(f"Couches gelées dans le backbone: {frozen_layers}")
print(f"Couches dégelées dans le backbone: {trainable_layers} (sur {len(backbone_layers)})")
print(f"Modèle d'embedding phase 2 créé:")
print(f"- Params totaux: {embedding_model_phase1.count_params():,}")
print(f"- Params entraînables: {sum([tf.size(w) for w in embedding_model_phase1.trainable_weights]):,}")
print(f"- Architecture: EfficientNetB0 + Fine Tuning ({embedding_dim}D)")
return embedding_model_phase1
def train_fine_tuning_phase2(embedding_model_phase1):
"""Entraînement complet avec toutes les optimisations"""
print("Début de l'entraînement Fine-Tuning phase 2...")
print("=" * 60)
# Charger les données
try:
recipes_df = pd.read_pickle("./data/recipes_with_images_dataframe.pkl")
print(f"{len(recipes_df)} recettes chargées depuis le DataFrame")
except FileNotFoundError:
print("Fichier ./data/recipes_with_images_dataframe.pkl introuvable")
print("Assurez-vous d'avoir exécuté le notebook 'raw' qui génère le DataFrame sous forme de pickle")
return None, None
print("\nCréation du modèle d'embedding phase 2...")
embedding_model_phase2 = create_embedding_model_phase2(
embedding_model_phase1,
embedding_dim=CONFIG_FT['EMBEDDING_DIM_CUSTOM']
)
# Créer les générateurs de données (train + validation)
print("\nCréation des générateurs de données...")
train_generator = TripletGenerator(
recipes_df,
batch_size=CONFIG_FT['BATCH_SIZE'],
img_size=CONFIG_FT['IMG_SIZE'],
augment=CONFIG_FT['USE_AUGMENTATION'],
validation_split=CONFIG_FT['VALIDATION_SPLIT'],
is_validation=False
)
show_triplets(train_generator, n_triplets=10, title="Triplets train")
val_generator = TripletGenerator(
recipes_df,
batch_size=CONFIG_FT['BATCH_SIZE'],
img_size=CONFIG_FT['IMG_SIZE'],
augment=False, # Pas d'augmentation en validation
validation_split=CONFIG_FT['VALIDATION_SPLIT'],
is_validation=True
)
show_triplets(val_generator, n_triplets=10, title="Triplets val")
# Créer le modèle triplet phase 2
triplet_model_phase2 = create_triplet_model(embedding_model_phase2)
# Compiler le modèle phase 2 entrainement des couches dégelées
triplet_model_phase2.compile(
optimizer=Adam(
learning_rate=CONFIG_FT['BACKBONE_LR'],
weight_decay=CONFIG_FT['WEIGHT_DECAY']
),
loss=triplet_loss(margin=CONFIG_FT['TRIPLET_MARGIN']),
metrics=[triplet_margin_accuracy, average_positive_similarity, average_negative_similarity]
)
print(f"Modèle phase 2 compilé (entrainement des couches dégelées):")
print(f"- Optimizer: Adam (lr={CONFIG_FT['BACKBONE_LR']}, wd={CONFIG_FT['WEIGHT_DECAY']})")
print(f"- Loss: Triplet Loss (margin={CONFIG_FT['TRIPLET_MARGIN']})")
print(f"- Métriques: Accuracy + Similarités moyenne")
# CALLBACK PERSONNALISÉ pour adapter le margin de triplet loss
class AdaptiveMarginCallback(tf.keras.callbacks.Callback):
def __init__(self, initial_margin=CONFIG_FT['TRIPLET_MARGIN']):
self.margin = initial_margin
def on_epoch_end(self, epoch, logs=None):
triplet_acc = logs.get('triplet_margin_accuracy', 0)
if triplet_acc > 0.95: # Trop facile
self.margin += 0.1
print(f"Augmentation margin à {self.margin}")
elif triplet_acc < 0.7: # Trop difficile
self.margin -= 0.05
print(f"Réduction margin à {self.margin}")
# CALLBACK PERSONNALISÉ pour sauvegarder UNIQUEMENT l'embedding model (et pas le triplet model)
class EmbeddingModelCheckpoint(tf.keras.callbacks.Callback):
"""
Callback personnalisé qui sauvegarde l'embedding model (pas le triplet model)
C'est CRUCIAL car ModelCheckpoint standard sauvegarderait le triplet model !
"""
def __init__(self, embedding_model, filepath, monitor='val_loss', save_best_only=True, verbose=1):
super().__init__()
self.embedding_model = embedding_model # Le modèle qui nous intéresse
self.filepath = filepath
self.monitor = monitor
self.save_best_only = save_best_only
self.verbose = verbose
self.best_value = np.inf if 'loss' in monitor else -np.inf
def on_epoch_end(self, epoch, logs=None):
current_value = logs.get(self.monitor)
if current_value is None:
if self.verbose > 0:
print(f"\n Métrique '{self.monitor}' non trouvée dans les logs")
return
improved = False
if 'loss' in self.monitor or 'error' in self.monitor:
# Pour les métriques à minimiser
if current_value < self.best_value:
self.best_value = current_value
improved = True
else:
# Pour les métriques à maximiser (accuracy, etc.)
if current_value > self.best_value:
self.best_value = current_value
improved = True
if improved or not self.save_best_only:
try:
# SAUVEGARDER L'EMBEDDING MODEL si amélioration (pas le triplet model)
if improved:
self.embedding_model.save(self.filepath)
print(f"\nNOUVEAU MEILLEUR MODELE D'EMBEDDINGS sauvegardé!")
print(f"Fichier: {self.filepath}")
print(f"{self.monitor}: {current_value:.4f}")
else:
print(f"\nPas d'amélioration du modèle d'embeddings")
except Exception as e:
if self.verbose > 0:
print(f"\nErreur sauvegarde embedding model: {e}")
def on_train_end(self, logs=None):
if self.verbose > 0:
print(f"\nEntraînement terminé. Meilleur {self.monitor}: {self.best_value:.4f}")
print(f"Meilleur embedding model disponible: {self.filepath}")
callbacks_phase2 = [
EarlyStopping(
monitor='val_loss',
patience=CONFIG_FT['PATIENCE'],
restore_best_weights=True,
verbose=1,
mode='min'
),
ReduceLROnPlateau(
monitor='val_loss',
patience=CONFIG_FT['REDUCE_LR_PATIENCE'],
factor=CONFIG_FT['REDUCE_LR_FACTOR'],
min_lr=CONFIG_FT['MIN_LR'],
verbose=1,
mode='min'
),
ModelCheckpoint(
f"./ft/best_triplet_{CONFIG_FT['MODEL_NAME']}",
monitor='val_loss',
save_best_only=True,
save_weights_only=False,
verbose=1,
mode='min'
),
AdaptiveMarginCallback(initial_margin=CONFIG_FT['TRIPLET_MARGIN']),
EmbeddingModelCheckpoint(
embedding_model_phase2,
f"./ft/best_embedding_{CONFIG_FT['MODEL_NAME']}",
monitor='val_loss',
save_best_only=True,
verbose=1,
),
TensorBoard(
log_dir=f"./ft/logs/{CONFIG_FT['MODEL_NAME']}",
histogram_freq=1,
write_graph=True,
write_images=True,
update_freq='epoch',
profile_batch=2,
embeddings_freq=1
)
]
print(f"Callbacks configurés pour phase 2:")
print(f"- Adaptive Margin: initial={CONFIG_FT['TRIPLET_MARGIN']}")
print(f"- Early Stopping: patience={CONFIG_FT['PATIENCE']} (val_loss)")
print(f"- Reduce LR: patience={CONFIG_FT['REDUCE_LR_PATIENCE']}, factor={CONFIG_FT['REDUCE_LR_FACTOR']}")
print(f"- Model Checkpoint: best_{CONFIG_FT['MODEL_NAME']}")
# Entraînement
print("\n" + "="*60)
print("DÉBUT DE L'ENTRAÎNEMENT")
print("="*60)
print(f"- Entraînement: {len(train_generator)} batch/époque")
print(f"- Validation: {len(val_generator)} batch/époque")
print(f"- Objectif: apprendre des embeddings discriminants via triplet loss")
start_time_phase2 = time.time()
print("\nEntraînement phase 2...")
history_phase2 = triplet_model_phase2.fit(
train_generator,
epochs=CONFIG_FT['BACKBONE_EPOCHS'],
validation_data=val_generator,
callbacks=callbacks_phase2,
verbose=1
)
training_time_phase2 = time.time() - start_time_phase2
# Afficher les résultats
print("\n" + "="*60)
print(" ENTRAÎNEMENT PHASE 2 TERMINÉ AVEC SUCCÈS!")
print("="*60)
print(f"⏱ Temps total: {training_time_phase2/60:.1f} minutes")
print(f" Meilleure val_loss: {min(history_phase2.history['val_loss']):.4f}")
print(f" Précision finale: {history_phase2.history['val_triplet_margin_accuracy'][-1]:.4f}")
print(f" Similarité pos finale: {history_phase2.history['val_average_positive_similarity'][-1]:.4f}")
print(f" Similarité neg finale: {history_phase2.history['val_average_negative_similarity'][-1]:.4f}")
print(f" Modèle sauvegardé: {CONFIG_FT['MODEL_NAME']}")
return embedding_model_phase2, history_phase2
6. Visualisation des résultats entraînement pour phase 2¶
In [13]:
def plot_training_results(history):
"""Afficher les métriques d'entraînement avec échelles adaptées"""
# Vérifier que les métriques existent
required_metrics = ['loss', 'val_loss', 'triplet_margin_accuracy', 'val_triplet_margin_accuracy']
for metric in required_metrics:
if metric not in history.history:
print(f"Métrique manquante: {metric}")
return
# Configuration dark mode (identique)
plt.style.use('dark_background')
colors = {
'primary': '#00D4AA',
'secondary': '#FF6B6B',
'accent': '#4ECDC4',
'warning': '#FFE66D',
'info': '#A8E6CF',
'purple': '#B19CD9'
}
fig, axes = plt.subplots(2, 2, figsize=(16, 12))
fig.patch.set_facecolor('#1e1e1e')
fig.suptitle('Résultats d\'Entraînement Fine-Tuning',
fontsize=18, fontweight='bold', color='white', y=0.95)
for ax in axes.flat:
ax.set_facecolor('#2d2d2d')
ax.tick_params(colors='white', which='both')
ax.xaxis.label.set_color('white')
ax.yaxis.label.set_color('white')
ax.title.set_color('white')
ax.grid(True, alpha=0.2, color='gray', linestyle='-', linewidth=0.5)
for spine in ax.spines.values():
spine.set_color('white')
# Loss
axes[0, 0].plot(history.history['loss'], label='Train Loss',
linewidth=3, color=colors['primary'], alpha=0.9)
axes[0, 0].plot(history.history['val_loss'], label='Val Loss',
linewidth=3, color=colors['secondary'], alpha=0.9)
axes[0, 0].fill_between(range(len(history.history['loss'])),
history.history['loss'], alpha=0.1, color=colors['primary'])
axes[0, 0].fill_between(range(len(history.history['val_loss'])),
history.history['val_loss'], alpha=0.1, color=colors['secondary'])
axes[0, 0].set_title('Triplet Loss Evolution', fontweight='bold', fontsize=14)
axes[0, 0].set_xlabel('Époque', fontweight='bold')
axes[0, 0].set_ylabel('Loss Value', fontweight='bold')
axes[0, 0].legend(frameon=True, fancybox=True, shadow=True,
facecolor='#3d3d3d', edgecolor='white')
# Accuracy
axes[0, 1].plot(history.history['triplet_margin_accuracy'], label='Train Margin Accuracy',
linewidth=3, color=colors['accent'], alpha=0.9)
axes[0, 1].plot(history.history['val_triplet_margin_accuracy'], label='Val Margin Accuracy',
linewidth=3, color=colors['warning'], alpha=0.9)
axes[0, 1].axhline(y=0.8, color='white', linestyle='--', alpha=0.5, label='Target (80%)')
axes[0, 1].set_title('Triplet Margin Accuracy Progress', fontweight='bold', fontsize=14)
axes[0, 1].set_xlabel('Époque', fontweight='bold')
axes[0, 1].set_ylabel('Margin Accuracy Score', fontweight='bold')
axes[0, 1].legend(frameon=True, fancybox=True, shadow=True,
facecolor='#3d3d3d', edgecolor='white')
axes[0, 1].set_ylim(0, 1) # ✅ Parfait
# Positive Similarity
if 'average_positive_similarity' in history.history:
axes[1, 0].plot(history.history['average_positive_similarity'], label='Train Pos Sim',
linewidth=3, color=colors['info'], alpha=0.9)
axes[1, 0].plot(history.history['val_average_positive_similarity'], label='Val Pos Sim',
linewidth=3, color=colors['purple'], alpha=0.9)
axes[1, 0].set_ylim(0, 1)
axes[1, 0].axhspan(0.7, 1.0, alpha=0.1, color='green', label='Target Zone (>0.7)')
axes[1, 0].axhline(y=0.7, color='white', linestyle='--', alpha=0.5)
axes[1, 0].set_title('Positive Similarity (Anchor-Positive)', fontweight='bold', fontsize=14)
axes[1, 0].set_xlabel('Époque', fontweight='bold')
axes[1, 0].set_ylabel('Cosine Similarity', fontweight='bold')
axes[1, 0].legend(frameon=True, fancybox=True, shadow=True,
facecolor='#3d3d3d', edgecolor='white')
# Negative Similarity
if 'average_negative_similarity' in history.history:
axes[1, 1].plot(history.history['average_negative_similarity'], label='Train Neg Sim',
linewidth=3, color=colors['secondary'], alpha=0.9)
axes[1, 1].plot(history.history['val_average_negative_similarity'], label='Val Neg Sim',
linewidth=3, color=colors['primary'], alpha=0.9)
axes[1, 1].set_ylim(-0.5, 0.5)
axes[1, 1].axhspan(-0.5, 0.3, alpha=0.1, color='red', label='Target Zone (<0.3)')
axes[1, 1].axhline(y=0.3, color='white', linestyle='--', alpha=0.5)
axes[1, 1].set_title('Negative Similarity (Anchor-Negative)', fontweight='bold', fontsize=14)
axes[1, 1].set_xlabel('Époque', fontweight='bold')
axes[1, 1].set_ylabel('Cosine Similarity', fontweight='bold')
axes[1, 1].legend(frameon=True, fancybox=True, shadow=True,
facecolor='#3d3d3d', edgecolor='white')
plt.tight_layout()
plt.subplots_adjust(top=0.92)
plt.show()
plt.style.use('default')
# Résumé amélioré
print("\nRÉSUMÉ DES MÉTRIQUES FINALES:")
print("-" * 50)
final_metrics = {}
if 'val_loss' in history.history:
final_metrics['Loss (validation)'] = history.history['val_loss'][-1]
if 'val_triplet_margin_accuracy' in history.history:
final_metrics['Margin Accuracy (validation)'] = history.history['val_triplet_margin_accuracy'][-1]
if 'val_average_positive_similarity' in history.history:
final_metrics['Similarité Positive'] = history.history['val_average_positive_similarity'][-1]
if 'val_average_negative_similarity' in history.history:
final_metrics['Similarité Négative'] = history.history['val_average_negative_similarity'][-1]
# Calcul de l'écart seulement si les deux métriques existent
if 'val_average_positive_similarity' in history.history and 'val_average_negative_similarity' in history.history:
final_metrics['Écart Pos-Neg'] = (history.history['val_average_positive_similarity'][-1] -
history.history['val_average_negative_similarity'][-1])
for metric, value in final_metrics.items():
print(f"{metric:25} : {value:.4f}")
# Interprétation
print("\nINTERPRÉTATION:")
if 'val_triplet_margin_accuracy' in history.history:
acc = history.history['val_triplet_margin_accuracy'][-1]
if acc > 0.85:
print(f"✅ Excellente accuracy ({acc:.1%})")
elif acc > 0.75:
print(f"🟡 Bonne accuracy ({acc:.1%})")
else:
print(f"❌ Accuracy faible ({acc:.1%}) - modèle à améliorer")
7. Exécution effective de l'entraînement du modèle¶
In [14]:
# Entraîner la tête uniquement
embedding_model1, history1 = train_transfer_learning_phase1()
# Entraînement des couches dégelées
embedding_model2, history2 = train_fine_tuning_phase2(embedding_model1)
if embedding_model2 is not None and history2 is not None:
# Afficher les résultats
plot_training_results(history2)
print("\nSUCCÈS! Entraînement terminé.")
print(f"Modèle prêt: {CONFIG_FT['MODEL_NAME']}")
print("Prêt pour l'extraction d'embeddings et la recherche par similarité!")
else:
print("Échec de l'entraînement. Vérifiez les données et ressayez.")
Début de l'entraînement Fine-Tuning phase 1... ============================================================ 13463 recettes chargées depuis le DataFrame Création du modèle d'embedding phase 1... Modèle d'embedding phase 1 créé: - Params totaux: 4,705,443 - Params entraînables: 655,872 - Architecture: EfficientNetB0 + Fine Tuning, phase 1 (512D) Création des générateurs de données... Filtrage des images valides...
Validation images: 100%|██████████| 13463/13463 [00:04<00:00, 3153.33it/s]
13463/13463 images valides Générateur Entraînement créé: - Recettes: 10618 - Images: 10774 - Augmentation: Activée Filtrage des images valides...
Validation images: 100%|██████████| 13463/13463 [00:03<00:00, 3403.02it/s]
13463/13463 images valides Générateur Validation créé: - Recettes: 2655 - Images: 2689 - Augmentation: Désactivée Modèle triplet créé: - Input shape: (None, 3, 224, 224, 3) - Output shape: (None, 3, 512) Modèle phase 1 compilé (entrainement de la tête uniquement): - Optimizer: Adam (lr=0.001, wd=0.0001) - Loss: Triplet Loss (margin=0.8) - Métriques: Accuracy + Similarités moyenne 6 époques fixées pour l'entraînement phase 1 car on a déjà testé et on a trouvé que c'est suffisant Callbacks configurés pour phase 1: - Reduce LR: patience=2, factor=0.5 - Adaptive Margin: initial=0.8 Entraînement phase 1... Epoch 1/6 336/336 ━━━━━━━━━━━━━━━━━━━━ 0s 875ms/step - average_negative_similarity: 0.0223 - average_positive_similarity: 0.8432 - loss: 0.0630 - triplet_margin_accuracy: 0.5701Réduction margin à 0.75 336/336 ━━━━━━━━━━━━━━━━━━━━ 393s 1s/step - average_negative_similarity: 0.0223 - average_positive_similarity: 0.8433 - loss: 0.0630 - triplet_margin_accuracy: 0.5703 - val_average_negative_similarity: 0.0105 - val_average_positive_similarity: 0.9884 - val_loss: 0.0207 - val_triplet_margin_accuracy: 0.8624 - learning_rate: 0.0010 Epoch 2/6 336/336 ━━━━━━━━━━━━━━━━━━━━ 0s 957ms/step - average_negative_similarity: 0.0078 - average_positive_similarity: 0.8781 - loss: 0.0422 - triplet_margin_accuracy: 0.6766Réduction margin à 0.7 336/336 ━━━━━━━━━━━━━━━━━━━━ 355s 1s/step - average_negative_similarity: 0.0078 - average_positive_similarity: 0.8781 - loss: 0.0422 - triplet_margin_accuracy: 0.6766 - val_average_negative_similarity: 0.0037 - val_average_positive_similarity: 0.9900 - val_loss: 0.0197 - val_triplet_margin_accuracy: 0.8661 - learning_rate: 0.0010 Epoch 3/6 336/336 ━━━━━━━━━━━━━━━━━━━━ 0s 1s/step - average_negative_similarity: 0.0075 - average_positive_similarity: 0.8836 - loss: 0.0413 - triplet_margin_accuracy: 0.6973Réduction margin à 0.6499999999999999 336/336 ━━━━━━━━━━━━━━━━━━━━ 393s 1s/step - average_negative_similarity: 0.0075 - average_positive_similarity: 0.8836 - loss: 0.0413 - triplet_margin_accuracy: 0.6973 - val_average_negative_similarity: 0.0065 - val_average_positive_similarity: 0.9916 - val_loss: 0.0182 - val_triplet_margin_accuracy: 0.8769 - learning_rate: 0.0010 Epoch 4/6 336/336 ━━━━━━━━━━━━━━━━━━━━ 330s 982ms/step - average_negative_similarity: 0.0080 - average_positive_similarity: 0.8873 - loss: 0.0385 - triplet_margin_accuracy: 0.6967 - val_average_negative_similarity: 0.0117 - val_average_positive_similarity: 0.9894 - val_loss: 0.0186 - val_triplet_margin_accuracy: 0.8713 - learning_rate: 0.0010 Epoch 5/6 336/336 ━━━━━━━━━━━━━━━━━━━━ 0s 1s/step - average_negative_similarity: 0.0079 - average_positive_similarity: 0.8922 - loss: 0.0355 - triplet_margin_accuracy: 0.7155 Epoch 5: ReduceLROnPlateau reducing learning rate to 0.0005000000237487257. 336/336 ━━━━━━━━━━━━━━━━━━━━ 399s 1s/step - average_negative_similarity: 0.0079 - average_positive_similarity: 0.8922 - loss: 0.0355 - triplet_margin_accuracy: 0.7155 - val_average_negative_similarity: 0.0068 - val_average_positive_similarity: 0.9890 - val_loss: 0.0200 - val_triplet_margin_accuracy: 0.8765 - learning_rate: 0.0010 Epoch 6/6 336/336 ━━━━━━━━━━━━━━━━━━━━ 370s 1s/step - average_negative_similarity: 0.0027 - average_positive_similarity: 0.8901 - loss: 0.0338 - triplet_margin_accuracy: 0.7290 - val_average_negative_similarity: -8.5093e-04 - val_average_positive_similarity: 0.9899 - val_loss: 0.0163 - val_triplet_margin_accuracy: 0.8910 - learning_rate: 5.0000e-04 ============================================================ ENTRAÎNEMENT PHASE 1 TERMINÉ AVEC SUCCÈS! ============================================================ ⏱ Temps total: 37.4 minutes Meilleure val_loss: 0.0163 Précision finale: 0.8910 Similarité pos finale: 0.9899 Similarité neg finale: -0.0009 Début de l'entraînement Fine-Tuning phase 2... ============================================================ 13463 recettes chargées depuis le DataFrame Création du modèle d'embedding phase 2... Total des couches EfficientNet + custom head: 241 Dégel des 40 dernières couches du backbone... Couches gelées dans le backbone: 196 Couches dégelées dans le backbone: 40 (sur 236) Modèle d'embedding phase 2 créé: - Params totaux: 4,705,443 - Params entraînables: 2,706,320 - Architecture: EfficientNetB0 + Fine Tuning (512D) Création des générateurs de données... Filtrage des images valides...
Validation images: 100%|██████████| 13463/13463 [00:04<00:00, 3365.59it/s]
13463/13463 images valides Générateur Entraînement créé: - Recettes: 10618 - Images: 10774 - Augmentation: Activée Format du batch triplet: (32, 3, 224, 224, 3) === ANALYSE DE LA DIFFICULTÉ DES TRIPLETS === Triplet 1: - Distance anchor-positive: 7044.8242 - Distance anchor-negative: 10235.2021 - Ratio difficulté: 1.45 (DIFFICILE) Triplet 2: - Distance anchor-positive: 4186.1597 - Distance anchor-negative: 10199.2969 - Ratio difficulté: 2.44 (DIFFICILE) Triplet 3: - Distance anchor-positive: 2242.4802 - Distance anchor-negative: 9953.6650 - Ratio difficulté: 4.44 (FACILE) Triplet 4: - Distance anchor-positive: 7141.5078 - Distance anchor-negative: 17882.2500 - Ratio difficulté: 2.50 (DIFFICILE) Triplet 5: - Distance anchor-positive: 2502.4087 - Distance anchor-negative: 13176.4551 - Ratio difficulté: 5.27 (FACILE) Difficulté moyenne: 3.22 Évaluation: TRIPLETS TROP FACILES Image 1-Anchor: min=0.000, max=255.000, mean=152.484 Normalisée: min=0.000, max=1.000 Image 1-Positive: min=0.000, max=255.000, mean=170.142 Normalisée: min=0.000, max=1.000 Image 1-Negative: min=0.000, max=255.000, mean=111.477 Normalisée: min=0.000, max=1.000 Image 2-Anchor: min=0.000, max=255.000, mean=162.117 Normalisée: min=0.000, max=1.000 Image 2-Positive: min=0.000, max=255.000, mean=164.345 Normalisée: min=0.000, max=1.000 Image 2-Negative: min=0.000, max=255.000, mean=119.955 Normalisée: min=0.000, max=1.000 Image 3-Anchor: min=0.000, max=255.000, mean=91.465 Normalisée: min=0.000, max=1.000 Image 3-Positive: min=3.000, max=255.000, mean=90.102 Normalisée: min=0.000, max=1.000 Image 3-Negative: min=0.000, max=255.000, mean=121.246 Normalisée: min=0.000, max=1.000 Image 4-Anchor: min=0.000, max=255.000, mean=69.878 Normalisée: min=0.000, max=1.000 Image 4-Positive: min=0.000, max=249.000, mean=67.227 Normalisée: min=0.000, max=1.000 Image 4-Negative: min=6.000, max=255.000, mean=169.511 Normalisée: min=0.000, max=1.000 Image 5-Anchor: min=9.000, max=255.000, mean=214.621 Normalisée: min=0.000, max=1.000 Image 5-Positive: min=9.000, max=255.000, mean=226.653 Normalisée: min=0.000, max=1.000 Image 5-Negative: min=0.000, max=255.000, mean=134.432 Normalisée: min=0.000, max=1.000 Image 6-Anchor: min=0.000, max=255.000, mean=45.241 Normalisée: min=0.000, max=1.000 Image 6-Positive: min=0.000, max=254.000, mean=115.125 Normalisée: min=0.000, max=1.000 Image 6-Negative: min=0.000, max=255.000, mean=152.106 Normalisée: min=0.000, max=1.000 Image 7-Anchor: min=0.000, max=255.000, mean=121.061 Normalisée: min=0.000, max=1.000 Image 7-Positive: min=0.000, max=255.000, mean=128.955 Normalisée: min=0.000, max=1.000 Image 7-Negative: min=0.000, max=255.000, mean=92.660 Normalisée: min=0.000, max=1.000 Image 8-Anchor: min=0.000, max=255.000, mean=96.686 Normalisée: min=0.000, max=1.000 Image 8-Positive: min=0.000, max=255.000, mean=89.735 Normalisée: min=0.000, max=1.000 Image 8-Negative: min=0.000, max=255.000, mean=50.464 Normalisée: min=0.000, max=1.000 Image 9-Anchor: min=0.000, max=255.000, mean=115.768 Normalisée: min=0.000, max=1.000 Image 9-Positive: min=0.000, max=233.000, mean=102.470 Normalisée: min=0.000, max=1.000 Image 9-Negative: min=0.000, max=255.000, mean=147.208 Normalisée: min=0.000, max=1.000 Image 10-Anchor: min=0.000, max=255.000, mean=178.002 Normalisée: min=0.000, max=1.000 Image 10-Positive: min=0.000, max=255.000, mean=191.798 Normalisée: min=0.000, max=1.000 Image 10-Negative: min=0.000, max=255.000, mean=163.659 Normalisée: min=0.000, max=1.000
Filtrage des images valides...
Validation images: 100%|██████████| 13463/13463 [00:04<00:00, 3124.26it/s]
13463/13463 images valides Générateur Validation créé: - Recettes: 2655 - Images: 2689 - Augmentation: Désactivée Format du batch triplet: (32, 3, 224, 224, 3) === ANALYSE DE LA DIFFICULTÉ DES TRIPLETS === Triplet 1: - Distance anchor-positive: 0.0000 - Distance anchor-negative: 10540.0518 - Ratio difficulté: 1054005175781.25 (FACILE) Triplet 2: - Distance anchor-positive: 0.0000 - Distance anchor-negative: 7908.7549 - Ratio difficulté: 790875488281.25 (FACILE) Triplet 3: - Distance anchor-positive: 0.0000 - Distance anchor-negative: 11798.2568 - Ratio difficulté: 1179825683593.75 (FACILE) Triplet 4: - Distance anchor-positive: 0.0000 - Distance anchor-negative: 15508.2998 - Ratio difficulté: 1550829980468.75 (FACILE) Triplet 5: - Distance anchor-positive: 0.0000 - Distance anchor-negative: 8330.0488 - Ratio difficulté: 833004882812.50 (FACILE) Difficulté moyenne: 1081708242187.50 Évaluation: TRIPLETS TROP FACILES Image 1-Anchor: min=0.000, max=255.000, mean=84.359 Normalisée: min=0.000, max=1.000 Image 1-Positive: min=0.000, max=255.000, mean=84.359 Normalisée: min=0.000, max=1.000 Image 1-Negative: min=0.000, max=255.000, mean=123.324 Normalisée: min=0.000, max=1.000 Image 2-Anchor: min=0.000, max=255.000, mean=140.940 Normalisée: min=0.000, max=1.000 Image 2-Positive: min=0.000, max=255.000, mean=140.940 Normalisée: min=0.000, max=1.000 Image 2-Negative: min=0.000, max=255.000, mean=157.824 Normalisée: min=0.000, max=1.000 Image 3-Anchor: min=0.000, max=255.000, mean=149.794 Normalisée: min=0.000, max=1.000 Image 3-Positive: min=0.000, max=255.000, mean=149.794 Normalisée: min=0.000, max=1.000 Image 3-Negative: min=0.000, max=255.000, mean=198.421 Normalisée: min=0.000, max=1.000 Image 4-Anchor: min=0.000, max=255.000, mean=100.366 Normalisée: min=0.000, max=1.000 Image 4-Positive: min=0.000, max=255.000, mean=100.366 Normalisée: min=0.000, max=1.000 Image 4-Negative: min=0.000, max=255.000, mean=152.692 Normalisée: min=0.000, max=1.000 Image 5-Anchor: min=0.000, max=255.000, mean=165.714 Normalisée: min=0.000, max=1.000 Image 5-Positive: min=0.000, max=255.000, mean=165.714 Normalisée: min=0.000, max=1.000 Image 5-Negative: min=0.000, max=255.000, mean=202.113 Normalisée: min=0.000, max=1.000 Image 6-Anchor: min=241.000, max=254.000, mean=246.993 Normalisée: min=0.000, max=1.000 Image 6-Positive: min=241.000, max=254.000, mean=246.993 Normalisée: min=0.000, max=1.000 Image 6-Negative: min=0.000, max=255.000, mean=172.582 Normalisée: min=0.000, max=1.000 Image 7-Anchor: min=0.000, max=255.000, mean=170.379 Normalisée: min=0.000, max=1.000 Image 7-Positive: min=0.000, max=255.000, mean=170.379 Normalisée: min=0.000, max=1.000 Image 7-Negative: min=0.000, max=255.000, mean=223.076 Normalisée: min=0.000, max=1.000 Image 8-Anchor: min=0.000, max=255.000, mean=98.346 Normalisée: min=0.000, max=1.000 Image 8-Positive: min=0.000, max=255.000, mean=98.346 Normalisée: min=0.000, max=1.000 Image 8-Negative: min=0.000, max=255.000, mean=165.280 Normalisée: min=0.000, max=1.000 Image 9-Anchor: min=0.000, max=255.000, mean=193.940 Normalisée: min=0.000, max=1.000 Image 9-Positive: min=0.000, max=255.000, mean=193.940 Normalisée: min=0.000, max=1.000 Image 9-Negative: min=0.000, max=255.000, mean=125.364 Normalisée: min=0.000, max=1.000 Image 10-Anchor: min=0.000, max=255.000, mean=233.588 Normalisée: min=0.000, max=1.000 Image 10-Positive: min=0.000, max=255.000, mean=233.588 Normalisée: min=0.000, max=1.000 Image 10-Negative: min=0.000, max=255.000, mean=163.637 Normalisée: min=0.000, max=1.000
